home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 1997 December / PC Pro December 1997 CD-Rom coverdisc.iso / symantec / dbAnywh / JAVA.BIN / CLASSES.ZIP / sun / tools / asm / Assembler.class (.txt) < prev    next >
Encoding:
Java Class File  |  1996-12-14  |  9.4 KB  |  602 lines
  1. package sun.tools.asm;
  2.  
  3. import java.io.DataOutputStream;
  4. import java.io.IOException;
  5. import java.io.PrintStream;
  6. import java.util.Enumeration;
  7. import java.util.Vector;
  8. import sun.tools.java.CompilerError;
  9. import sun.tools.java.Constants;
  10. import sun.tools.java.Environment;
  11. import sun.tools.java.FieldDefinition;
  12.  
  13. public final class Assembler implements Constants {
  14.    static final int NOTREACHED = 0;
  15.    static final int REACHED = 1;
  16.    static final int NEEDED = 2;
  17.    Label first = new Label();
  18.    Instruction last;
  19.    int maxdepth;
  20.    int maxvar;
  21.    int maxpc;
  22.  
  23.    public void add(Instruction var1) {
  24.       if (var1 != null) {
  25.          this.last.next = var1;
  26.          this.last = var1;
  27.       }
  28.  
  29.    }
  30.  
  31.    public void add(int var1, int var2) {
  32.       this.add(new Instruction(var1, var2, (Object)null));
  33.    }
  34.  
  35.    public void add(int var1, int var2, Object var3) {
  36.       this.add(new Instruction(var1, var2, var3));
  37.    }
  38.  
  39.    void optimize(Environment var1, Label var2) {
  40.       var2.pc = 1;
  41.  
  42.       for(Instruction var3 = var2.next; var3 != null; var3 = var3.next) {
  43.          switch (var3.pc) {
  44.             case 0:
  45.                var3.optimize(var1);
  46.                var3.pc = 1;
  47.                break;
  48.             case 1:
  49.                return;
  50.             case 2:
  51.          }
  52.  
  53.          switch (var3.opc) {
  54.             case -3:
  55.                TryData var7 = (TryData)var3.value;
  56.                var7.getEndLabel().pc = 2;
  57.                Enumeration var8 = var7.catches.elements();
  58.  
  59.                while(var8.hasMoreElements()) {
  60.                   CatchData var6 = (CatchData)var8.nextElement();
  61.                   this.optimize(var1, var6.getLabel());
  62.                }
  63.                break;
  64.             case -2:
  65.             case -1:
  66.                if (var3.pc == 1) {
  67.                   var3.pc = 0;
  68.                }
  69.                break;
  70.             case 153:
  71.             case 154:
  72.             case 155:
  73.             case 156:
  74.             case 157:
  75.             case 158:
  76.             case 159:
  77.             case 160:
  78.             case 161:
  79.             case 162:
  80.             case 163:
  81.             case 164:
  82.             case 165:
  83.             case 166:
  84.             case 198:
  85.             case 199:
  86.                this.optimize(var1, (Label)var3.value);
  87.                break;
  88.             case 167:
  89.                this.optimize(var1, (Label)var3.value);
  90.                return;
  91.             case 168:
  92.                this.optimize(var1, (Label)var3.value);
  93.                break;
  94.             case 169:
  95.             case 172:
  96.             case 173:
  97.             case 174:
  98.             case 175:
  99.             case 176:
  100.             case 177:
  101.             case 191:
  102.                return;
  103.             case 170:
  104.             case 171:
  105.                SwitchData var4 = (SwitchData)var3.value;
  106.                this.optimize(var1, var4.defaultLabel);
  107.                Enumeration var5 = var4.tab.elements();
  108.  
  109.                while(var5.hasMoreElements()) {
  110.                   this.optimize(var1, (Label)var5.nextElement());
  111.                }
  112.  
  113.                return;
  114.          }
  115.       }
  116.  
  117.    }
  118.  
  119.    boolean eliminate() {
  120.       boolean var1 = false;
  121.       Object var2 = this.first;
  122.  
  123.       for(Instruction var3 = this.first.next; var3 != null; var3 = var3.next) {
  124.          if (var3.pc != 0) {
  125.             ((Instruction)var2).next = var3;
  126.             var2 = var3;
  127.             var3.pc = 0;
  128.          } else {
  129.             var1 = true;
  130.          }
  131.       }
  132.  
  133.       this.first.pc = 0;
  134.       ((Instruction)var2).next = null;
  135.       return var1;
  136.    }
  137.  
  138.    public void optimize(Environment var1) {
  139.       do {
  140.          this.optimize(var1, this.first);
  141.       } while(this.eliminate() && var1.optimize());
  142.  
  143.    }
  144.  
  145.    public void collect(Environment var1, FieldDefinition var2, ConstantPool var3) {
  146.       if (var2 != null && var1.debug() && var2.getArguments() != null) {
  147.          Enumeration var4 = var2.getArguments().elements();
  148.  
  149.          while(var4.hasMoreElements()) {
  150.             FieldDefinition var5 = (FieldDefinition)var4.nextElement();
  151.             var3.put(var5.getName().toString());
  152.             var3.put(var5.getType().getTypeSignature());
  153.          }
  154.       }
  155.  
  156.       for(Object var6 = this.first; var6 != null; var6 = ((Instruction)var6).next) {
  157.          ((Instruction)var6).collect(var3);
  158.       }
  159.  
  160.    }
  161.  
  162.    void balance(Label var1, int var2) {
  163.       for(Object var3 = var1; var3 != null; var3 = ((Instruction)var3).next) {
  164.          var2 += ((Instruction)var3).balance();
  165.          if (var2 < 0) {
  166.             throw new CompilerError("stack under flow: " + ((Instruction)var3).toString() + " = " + var2);
  167.          }
  168.  
  169.          if (var2 > this.maxdepth) {
  170.             this.maxdepth = var2;
  171.          }
  172.  
  173.          switch (((Instruction)var3).opc) {
  174.             case -3:
  175.                TryData var11 = (TryData)((Instruction)var3).value;
  176.                Enumeration var12 = var11.catches.elements();
  177.  
  178.                while(var12.hasMoreElements()) {
  179.                   CatchData var6 = (CatchData)var12.nextElement();
  180.                   this.balance(var6.getLabel(), var2 + 1);
  181.                }
  182.                break;
  183.             case -1:
  184.                var1 = (Label)var3;
  185.                if (((Instruction)var3).pc == 1) {
  186.                   if (var1.depth != var2) {
  187.                      throw new CompilerError("stack depth error " + var2 + "/" + var1.depth);
  188.                   }
  189.  
  190.                   return;
  191.                }
  192.  
  193.                var1.pc = 1;
  194.                var1.depth = var2;
  195.                break;
  196.             case 21:
  197.             case 23:
  198.             case 25:
  199.             case 54:
  200.             case 56:
  201.             case 58:
  202.                int var10 = (((Instruction)var3).value instanceof Number ? ((Number)((Instruction)var3).value).intValue() : ((LocalVariable)((Instruction)var3).value).slot) + 1;
  203.                if (var10 > this.maxvar) {
  204.                   this.maxvar = var10;
  205.                }
  206.                break;
  207.             case 22:
  208.             case 24:
  209.             case 55:
  210.             case 57:
  211.                int var9 = (((Instruction)var3).value instanceof Number ? ((Number)((Instruction)var3).value).intValue() : ((LocalVariable)((Instruction)var3).value).slot) + 2;
  212.                if (var9 > this.maxvar) {
  213.                   this.maxvar = var9;
  214.                }
  215.                break;
  216.             case 132:
  217.                int var8 = ((int[])((Instruction)var3).value)[0] + 1;
  218.                if (var8 > this.maxvar) {
  219.                   this.maxvar = var8 + 1;
  220.                }
  221.                break;
  222.             case 153:
  223.             case 154:
  224.             case 155:
  225.             case 156:
  226.             case 157:
  227.             case 158:
  228.             case 159:
  229.             case 160:
  230.             case 161:
  231.             case 162:
  232.             case 163:
  233.             case 164:
  234.             case 165:
  235.             case 166:
  236.             case 198:
  237.             case 199:
  238.                this.balance((Label)((Instruction)var3).value, var2);
  239.                break;
  240.             case 167:
  241.                this.balance((Label)((Instruction)var3).value, var2);
  242.                return;
  243.             case 168:
  244.                this.balance((Label)((Instruction)var3).value, var2 + 1);
  245.                break;
  246.             case 169:
  247.             case 172:
  248.             case 173:
  249.             case 174:
  250.             case 175:
  251.             case 176:
  252.             case 177:
  253.             case 191:
  254.                return;
  255.             case 170:
  256.             case 171:
  257.                SwitchData var4 = (SwitchData)((Instruction)var3).value;
  258.                this.balance(var4.defaultLabel, var2);
  259.                Enumeration var5 = var4.tab.elements();
  260.  
  261.                while(var5.hasMoreElements()) {
  262.                   this.balance((Label)var5.nextElement(), var2);
  263.                }
  264.  
  265.                return;
  266.          }
  267.       }
  268.  
  269.    }
  270.  
  271.    public void write(Environment var1, DataOutputStream var2, FieldDefinition var3, ConstantPool var4) throws IOException {
  272.       if (var3 != null && var3.getArguments() != null) {
  273.          int var5 = 0;
  274.          Vector var6 = var3.getArguments();
  275.  
  276.          FieldDefinition var8;
  277.          for(Enumeration var7 = var6.elements(); var7.hasMoreElements(); var5 += var8.getType().stackSize()) {
  278.             var8 = (FieldDefinition)var7.nextElement();
  279.          }
  280.  
  281.          this.maxvar = var5;
  282.       }
  283.  
  284.       try {
  285.          this.balance(this.first, 0);
  286.       } catch (CompilerError var9) {
  287.          System.out.println("ERROR: " + var9);
  288.          this.listing(System.out);
  289.          throw var9;
  290.       }
  291.  
  292.       int var10 = 0;
  293.       int var11 = 0;
  294.  
  295.       for(Object var12 = this.first; var12 != null; var12 = ((Instruction)var12).next) {
  296.          ((Instruction)var12).pc = var10;
  297.          var10 += ((Instruction)var12).size(var4);
  298.          if (((Instruction)var12).opc == -3) {
  299.             var11 += ((TryData)((Instruction)var12).value).catches.size();
  300.          }
  301.       }
  302.  
  303.       var2.writeShort(this.maxdepth);
  304.       var2.writeShort(this.maxvar);
  305.       var2.writeInt(this.maxpc = var10);
  306.  
  307.       for(Instruction var13 = this.first.next; var13 != null; var13 = var13.next) {
  308.          var13.write(var2, var4);
  309.       }
  310.  
  311.       var2.writeShort(var11);
  312.       if (var11 > 0) {
  313.          this.writeExceptions(var1, var2, var4, this.first, this.last);
  314.       }
  315.  
  316.    }
  317.  
  318.    void writeExceptions(Environment var1, DataOutputStream var2, ConstantPool var3, Instruction var4, Instruction var5) throws IOException {
  319.       for(Object var6 = var4; var6 != var5.next; var6 = ((Instruction)var6).next) {
  320.          if (((Instruction)var6).opc == -3) {
  321.             TryData var7 = (TryData)((Instruction)var6).value;
  322.             this.writeExceptions(var1, var2, var3, ((Instruction)var6).next, var7.getEndLabel());
  323.             Enumeration var8 = var7.catches.elements();
  324.  
  325.             while(var8.hasMoreElements()) {
  326.                CatchData var9 = (CatchData)var8.nextElement();
  327.                var2.writeShort(((Instruction)var6).pc);
  328.                var2.writeShort(var7.getEndLabel().pc);
  329.                var2.writeShort(var9.getLabel().pc);
  330.                if (var9.getType() != null) {
  331.                   var2.writeShort(var3.index(var9.getType()));
  332.                } else {
  333.                   var2.writeShort(0);
  334.                }
  335.             }
  336.  
  337.             var6 = var7.getEndLabel();
  338.          }
  339.       }
  340.  
  341.    }
  342.  
  343.    public void writeLineNumberTable(Environment var1, DataOutputStream var2, ConstantPool var3) throws IOException {
  344.       int var4 = -1;
  345.       int var5 = 0;
  346.  
  347.       for(Object var6 = this.first; var6 != null; var6 = ((Instruction)var6).next) {
  348.          int var7 = ((Instruction)var6).where >> 18;
  349.          if (var7 > 0 && var4 != var7) {
  350.             var4 = var7;
  351.             ++var5;
  352.          }
  353.       }
  354.  
  355.       var4 = -1;
  356.       var2.writeShort(var5);
  357.  
  358.       for(Object var10 = this.first; var10 != null; var10 = ((Instruction)var10).next) {
  359.          int var8 = ((Instruction)var10).where >> 18;
  360.          if (var8 > 0 && var4 != var8) {
  361.             var4 = var8;
  362.             var2.writeShort(((Instruction)var10).pc);
  363.             var2.writeShort(var8);
  364.          }
  365.       }
  366.  
  367.    }
  368.  
  369.    void flowFields(Environment var1, Label var2, FieldDefinition[] var3) {
  370.       if (var2.locals != null) {
  371.          FieldDefinition[] var10 = var2.locals;
  372.  
  373.          for(int var11 = 0; var11 < this.maxvar; ++var11) {
  374.             if (var10[var11] != var3[var11]) {
  375.                var10[var11] = null;
  376.             }
  377.          }
  378.  
  379.       } else {
  380.          var2.locals = new FieldDefinition[this.maxvar];
  381.          System.arraycopy(var3, 0, var2.locals, 0, this.maxvar);
  382.          FieldDefinition[] var4 = new FieldDefinition[this.maxvar];
  383.          System.arraycopy(var3, 0, var4, 0, this.maxvar);
  384.          var3 = var4;
  385.  
  386.          for(Instruction var5 = var2.next; var5 != null; var5 = var5.next) {
  387.             switch (var5.opc) {
  388.                case -3:
  389.                   Vector var13 = ((TryData)var5.value).catches;
  390.                   Enumeration var14 = var13.elements();
  391.  
  392.                   while(var14.hasMoreElements()) {
  393.                      CatchData var8 = (CatchData)var14.nextElement();
  394.                      this.flowFields(var1, var8.getLabel(), var3);
  395.                   }
  396.                   break;
  397.                case -1:
  398.                   this.flowFields(var1, (Label)var5, var3);
  399.                   return;
  400.                case 54:
  401.                case 55:
  402.                case 56:
  403.                case 57:
  404.                case 58:
  405.                case 59:
  406.                case 60:
  407.                case 61:
  408.                case 62:
  409.                case 63:
  410.                case 64:
  411.                case 65:
  412.                case 66:
  413.                case 67:
  414.                case 68:
  415.                case 69:
  416.                case 70:
  417.                case 71:
  418.                case 72:
  419.                case 73:
  420.                case 74:
  421.                case 75:
  422.                case 76:
  423.                case 77:
  424.                case 78:
  425.                   if (var5.value instanceof LocalVariable) {
  426.                      LocalVariable var12 = (LocalVariable)var5.value;
  427.                      var3[var12.slot] = var12.field;
  428.                   }
  429.                   break;
  430.                case 153:
  431.                case 154:
  432.                case 155:
  433.                case 156:
  434.                case 157:
  435.                case 158:
  436.                case 159:
  437.                case 160:
  438.                case 161:
  439.                case 162:
  440.                case 163:
  441.                case 164:
  442.                case 165:
  443.                case 166:
  444.                case 168:
  445.                case 198:
  446.                case 199:
  447.                   this.flowFields(var1, (Label)var5.value, var3);
  448.                   break;
  449.                case 167:
  450.                   this.flowFields(var1, (Label)var5.value, var3);
  451.                   return;
  452.                case 169:
  453.                case 172:
  454.                case 173:
  455.                case 174:
  456.                case 175:
  457.                case 176:
  458.                case 177:
  459.                case 191:
  460.                   return;
  461.                case 170:
  462.                case 171:
  463.                   SwitchData var6 = (SwitchData)var5.value;
  464.                   this.flowFields(var1, var6.defaultLabel, var3);
  465.                   Enumeration var7 = var6.tab.elements();
  466.  
  467.                   while(var7.hasMoreElements()) {
  468.                      this.flowFields(var1, (Label)var7.nextElement(), var3);
  469.                   }
  470.  
  471.                   return;
  472.             }
  473.          }
  474.  
  475.       }
  476.    }
  477.  
  478.    public void writeLocalVariableTable(Environment var1, FieldDefinition var2, DataOutputStream var3, ConstantPool var4) throws IOException {
  479.       FieldDefinition[] var5 = new FieldDefinition[this.maxvar];
  480.       int var6 = 0;
  481.       if (var2 != null && var2.getArguments() != null) {
  482.          int var7 = 0;
  483.          Vector var8 = var2.getArguments();
  484.  
  485.          FieldDefinition var10;
  486.          for(Enumeration var9 = var8.elements(); var9.hasMoreElements(); var7 += var10.getType().stackSize()) {
  487.             var10 = (FieldDefinition)var9.nextElement();
  488.             var5[var7] = var10;
  489.          }
  490.       }
  491.  
  492.       this.flowFields(var1, this.first, var5);
  493.       LocalVariableTable var17 = new LocalVariableTable();
  494.  
  495.       for(int var12 = 0; var12 < this.maxvar; ++var12) {
  496.          var5[var12] = null;
  497.       }
  498.  
  499.       if (var2 != null && var2.getArguments() != null) {
  500.          int var18 = 0;
  501.          Vector var20 = var2.getArguments();
  502.  
  503.          FieldDefinition var11;
  504.          for(Enumeration var22 = var20.elements(); var22.hasMoreElements(); var18 += var11.getType().stackSize()) {
  505.             var11 = (FieldDefinition)var22.nextElement();
  506.             var5[var18] = var11;
  507.             var17.define(var11, var18, 0, this.maxpc);
  508.          }
  509.       }
  510.  
  511.       int[] var19 = new int[this.maxvar];
  512.  
  513.       for(Object var21 = this.first; var21 != null; var21 = ((Instruction)var21).next) {
  514.          switch (((Instruction)var21).opc) {
  515.             case -1:
  516.                var6 = 0;
  517.  
  518.                for(; var6 < this.maxvar; ++var6) {
  519.                   if (var5[var6] != null) {
  520.                      var17.define(var5[var6], var6, var19[var6], ((Instruction)var21).pc);
  521.                   }
  522.                }
  523.  
  524.                int var24 = ((Instruction)var21).pc;
  525.                FieldDefinition[] var26 = ((Label)var21).locals;
  526.                if (var26 == null) {
  527.                   for(int var14 = 0; var14 < this.maxvar; ++var14) {
  528.                      var5[var14] = null;
  529.                   }
  530.                } else {
  531.                   System.arraycopy(var26, 0, var5, 0, this.maxvar);
  532.                }
  533.  
  534.                for(int var15 = 0; var15 < this.maxvar; ++var15) {
  535.                   var19[var15] = var24;
  536.                }
  537.                break;
  538.             case 54:
  539.             case 55:
  540.             case 56:
  541.             case 57:
  542.             case 58:
  543.             case 59:
  544.             case 60:
  545.             case 61:
  546.             case 62:
  547.             case 63:
  548.             case 64:
  549.             case 65:
  550.             case 66:
  551.             case 67:
  552.             case 68:
  553.             case 69:
  554.             case 70:
  555.             case 71:
  556.             case 72:
  557.             case 73:
  558.             case 74:
  559.             case 75:
  560.             case 76:
  561.             case 77:
  562.             case 78:
  563.                if (((Instruction)var21).value instanceof LocalVariable) {
  564.                   LocalVariable var23 = (LocalVariable)((Instruction)var21).value;
  565.                   int var25 = ((Instruction)var21).next != null ? ((Instruction)var21).next.pc : ((Instruction)var21).pc;
  566.                   if (var5[var23.slot] != null) {
  567.                      var17.define(var5[var23.slot], var23.slot, var19[var23.slot], var25);
  568.                   }
  569.  
  570.                   var19[var23.slot] = var25;
  571.                   var5[var23.slot] = var23.field;
  572.                }
  573.          }
  574.       }
  575.  
  576.       for(int var16 = 0; var16 < this.maxvar; ++var16) {
  577.          if (var5[var16] != null) {
  578.             var17.define(var5[var16], var16, var19[var16], this.maxpc);
  579.          }
  580.       }
  581.  
  582.       var17.write(var1, var3, var4);
  583.    }
  584.  
  585.    public boolean empty() {
  586.       return this.first == this.last;
  587.    }
  588.  
  589.    public void listing(PrintStream var1) {
  590.       var1.println("-- listing --");
  591.  
  592.       for(Object var2 = this.first; var2 != null; var2 = ((Instruction)var2).next) {
  593.          var1.println(((Instruction)var2).toString());
  594.       }
  595.  
  596.    }
  597.  
  598.    public Assembler() {
  599.       this.last = this.first;
  600.    }
  601. }
  602.